package convert

import "strconv"

// StringToInt 将字符串转换为 int 类型。
func StringToInt(value string) (int, error) {
	return strconv.Atoi(value)
}

// StringToInt8 将字符串转换为 int8 类型。
func StringToInt8(value string) (int8, error) {
	temp, err := strconv.ParseInt(value, 10, 8) // 使用 ParseInt 解析为 int64，位大小限制为 8 位
	if err != nil {
		return 0, err // 解析错误时返回 0 和错误信息
	}
	return Int64ToInt8(temp) // 调用 Int64ToInt8 将 int64 转换为 int8
}

// StringToInt16 将字符串转换为 int16 类型。
func StringToInt16(value string) (int16, error) {
	temp, err := strconv.ParseInt(value, 10, 16) // 使用 ParseInt 解析为 int64，位大小限制为 16 位
	if err != nil {
		return 0, err // 解析错误时返回 0 和错误信息
	}
	return Int64ToInt16(temp) // 调用 Int64ToInt16 将 int64 转换为 int16
}

// StringToInt32 将字符串转换为 int32 类型。
func StringToInt32(value string) (int32, error) {
	temp, err := strconv.ParseInt(value, 10, 32) // 使用 ParseInt 解析为 int64，位大小限制为 32 位
	if err != nil {
		return 0, err // 解析错误时返回 0 和错误信息
	}
	return Int64ToInt32(temp) // 调用 Int64ToInt32 将 int64 转换为 int32
}

// StringToInt64 将字符串转换为 int64 类型。
func StringToInt64(value string) (int64, error) {
	return strconv.ParseInt(value, 10, 64) // 使用 ParseInt 解析为 int64，位大小限制为 64 位
}

// StringToUint 将字符串转换为 uint 类型。
func StringToUint(value string) (uint, error) {
	temp, err := strconv.ParseUint(value, 10, 0) // 使用 ParseUint 解析为 uint64，没有位大小限制
	if err != nil {
		return 0, err // 解析错误时返回 0 和错误信息
	}
	return Uint64ToUint(temp) // 调用 Uint64ToUint 将 uint64 转换为 uint
}

// StringToUint8 将字符串转换为 uint8 类型。
func StringToUint8(value string) (uint8, error) {
	temp, err := strconv.ParseUint(value, 10, 8) // 使用 ParseUint 解析为 uint64，位大小限制为 8 位
	if err != nil {
		return 0, err // 解析错误时返回 0 和错误信息
	}
	return Uint64ToUint8(temp) // 调用 Uint64ToUint8 将 uint64 转换为 uint8
}

// StringToUint16 将字符串转换为 uint16 类型。
func StringToUint16(value string) (uint16, error) {
	temp, err := strconv.ParseUint(value, 10, 16) // 使用 ParseUint 解析为 uint64，位大小限制为 16 位
	if err != nil {
		return 0, err // 解析错误时返回 0 和错误信息
	}
	return Uint64ToUint16(temp) // 调用 Uint64ToUint16 将 uint64 转换为 uint16
}

// StringToUint32 将字符串转换为 uint32 类型。
func StringToUint32(value string) (uint32, error) {
	temp, err := strconv.ParseUint(value, 10, 32) // 使用 ParseUint 解析为 uint64，位大小限制为 32 位
	if err != nil {
		return 0, err // 解析错误时返回 0 和错误信息
	}
	return Uint64ToUint32(temp) // 调用 Uint64ToUint32 将 uint64 转换为 uint32
}

// StringToUint64 将字符串转换为 uint64 类型。
func StringToUint64(value string) (uint64, error) {
	return strconv.ParseUint(value, 10, 64) // 使用 ParseUint 解析为 uint64，位大小限制为 64 位
}

// StringToFloat32 将字符串转换为 float32 类型。
func StringToFloat32(value string) (float32, error) {
	f64, err := strconv.ParseFloat(value, 32) // 使用 ParseFloat 解析为 float64，但结果被指定为 float32
	if err != nil {
		return 0, err // 解析错误时返回 0.0 和错误信息
	}
	return float32(f64), nil // 将 float64 强制转换为 float32
}

// StringToFloat64 将字符串转换为 float64 类型。
func StringToFloat64(value string) (float64, error) {
	return strconv.ParseFloat(value, 64) // 使用 ParseFloat 解析为 float64
}

// StringToBool 将字符串转换为 bool 类型。
func StringToBool(value string) (bool, error) {
	return strconv.ParseBool(value)
}
